home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / game / shoot / ADoom_src_1_2.lha / ADoom_src / r_draw.c < prev    next >
C/C++ Source or Header  |  1998-02-16  |  25KB  |  1,184 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    The actual span/column drawing functions.
  21. //    Here find the main potential for optimization,
  22. //     e.g. inline assembly, different algorithms.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char
  28. rcsid[] = "$Id: r_draw.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
  29.  
  30.  
  31. #include "doomdef.h"
  32.  
  33. #include "i_system.h"
  34. #include "i_video.h"
  35. #include "z_zone.h"
  36. #include "w_wad.h"
  37.  
  38. #include "r_local.h"
  39.  
  40. // Needs access to LFB (guess what).
  41. #include "v_video.h"
  42.  
  43. // State.
  44. #include "doomstat.h"
  45.  
  46.  
  47. // ?
  48. //#define MAXWIDTH            1120
  49. //#define MAXHEIGHT            832
  50.  
  51. // status bar height at bottom of screen
  52. #define SBARHEIGHT        32
  53.  
  54. //
  55. // All drawing to the view buffer is accomplished in this file.
  56. // The other refresh files only know about ccordinates,
  57. //  not the architecture of the frame buffer.
  58. // Conveniently, the frame buffer is a linear one,
  59. //  and we need only the base address,
  60. //  and the total size == width*height*depth/8.,
  61. //
  62.  
  63.  
  64. byte*        viewimage; 
  65. int        viewwidth;
  66. int        scaledviewwidth;
  67. int        viewheight;
  68. int        viewwindowx;
  69. int        viewwindowy; 
  70. //byte*        ylookup[MAXHEIGHT]; 
  71. //byte*        ylookup2[MAXHEIGHT]; 
  72. //int        columnofs[MAXWIDTH]; 
  73. byte*        *ylookup; 
  74. byte*        *ylookup2;
  75. int        *columnofs;
  76.  
  77. // Color tables for different players,
  78. //  translate a limited part to another
  79. //  (color ramps used for  suit colors).
  80. //
  81. FAR byte    translations[3][256];    
  82.  
  83.  
  84.  
  85. //
  86. // Spectre/Invisibility.
  87. //
  88. #define FUZZTABLE       50
  89. #define FUZZOFF    (1)
  90.  
  91. int    fuzzoffset_init[FUZZTABLE] =
  92. {
  93.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  94.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  95.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  96.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  97.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  98.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  99.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
  100. };
  101.  
  102. int    *fuzzoffset;
  103. int    fuzzpos = 0; 
  104.  
  105. void init_r_draw (void);
  106.  
  107. void resinit_r_draw (void)
  108. {
  109.   int i;
  110.  
  111.   ylookup = (byte **)I_malloc (SCREENHEIGHT * sizeof(byte *));
  112.   ylookup2 = (byte **)I_malloc (SCREENHEIGHT * sizeof(byte *));
  113.   columnofs = (int *)I_malloc (SCREENWIDTH * sizeof(int));
  114.  
  115.   fuzzoffset = I_malloc ((SCREENHEIGHT + 50) * sizeof(int));
  116.   for (i = 0; i < SCREENHEIGHT + 50; i++)
  117.     fuzzoffset[i] = fuzzoffset_init[i % FUZZTABLE] * SCREENWIDTH;
  118.   fuzzpos=0;
  119.  
  120.   init_r_draw ();
  121. }
  122.  
  123.  
  124.  
  125. //
  126. // R_DrawColumn
  127. // Source is the top of the column to scale.
  128. //
  129. lighttable_t*        dc_colormap; 
  130. int            dc_x; 
  131. int            dc_yl; 
  132. int            dc_yh; 
  133. fixed_t            dc_iscale; 
  134. fixed_t            dc_texturemid;
  135.  
  136. // first pixel in a column (possibly virtual) 
  137. byte*            dc_source;        
  138.  
  139. // just for profiling 
  140. int            dccount;
  141.  
  142. //
  143. // A column is a vertical slice/span from a wall texture that,
  144. //  given the DOOM style restrictions on the view orientation,
  145. //  will always have constant z depth.
  146. // Thus a special case loop for very fast rendering can
  147. //  be used. It has also been used with Wolfenstein 3D.
  148. // 
  149. // UNUSED.
  150. #ifndef AMIGA
  151. void R_DrawColumn (void) 
  152. { 
  153.     int            count; 
  154.     byte*        dest; 
  155.     fixed_t        frac;
  156.     fixed_t        fracstep;     
  157.  
  158.     count = dc_yh - dc_yl; 
  159.  
  160.     // Zero length, column does not exceed a pixel.
  161.     if (count < 0) 
  162.     return; 
  163.                  
  164. #ifdef RANGECHECK 
  165.     if ((unsigned)dc_x >= SCREENWIDTH
  166.     || dc_yl < 0
  167.     || dc_yh >= SCREENHEIGHT) 
  168.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
  169. #endif 
  170.  
  171.     // Framebuffer destination address.
  172.     // Use ylookup LUT to avoid multiply with ScreenWidth.
  173.     // Use columnofs LUT for subwindows? 
  174. //    dest = ylookup[dc_yl] + columnofs[dc_x];  
  175.     dest = ylookup2[dc_yl] + dc_x;
  176.  
  177.     // Determine scaling,
  178.     //  which is the only mapping to be done.
  179.     fracstep = dc_iscale; 
  180.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  181.  
  182.     // Inner loop that does the actual texture mapping,
  183.     //  e.g. a DDA-lile scaling.
  184.     // This is as fast as it gets.
  185.     do 
  186.     {
  187.     // Re-map color indices from wall texture column
  188.     //  using a lighting/special effects LUT.
  189.     *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  190.     
  191.     dest += SCREENWIDTH; 
  192.     frac += fracstep;
  193.     
  194.     } while (count--); 
  195. } 
  196. #endif
  197.  
  198. //void R_DrawColumn_040 (void)
  199. //{
  200. //  R_DrawColumn ();
  201. //}
  202. //
  203. //void R_DrawColumn_060 (void)
  204. //{
  205. //  R_DrawColumn ();
  206. //}
  207.  
  208. // UNUSED.
  209. // Loop unrolled.
  210. #if 0
  211. void R_DrawColumn (void) 
  212. { 
  213.     int            count; 
  214.     byte*        source;
  215.     byte*        dest;
  216.     byte*        colormap;
  217.     
  218.     unsigned        frac;
  219.     unsigned        fracstep;
  220.     unsigned        fracstep2;
  221.     unsigned        fracstep3;
  222.     unsigned        fracstep4;     
  223.  
  224.     count = dc_yh - dc_yl + 1; 
  225.  
  226.     source = dc_source;
  227.     colormap = dc_colormap;         
  228.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  229.      
  230.     fracstep = dc_iscale<<9; 
  231.     frac = (dc_texturemid + (dc_yl-centery)*dc_iscale)<<9; 
  232.  
  233.     fracstep2 = fracstep+fracstep;
  234.     fracstep3 = fracstep2+fracstep;
  235.     fracstep4 = fracstep3+fracstep;
  236.     
  237.     while (count >= 8) 
  238.     { 
  239.     dest[0] = colormap[source[frac>>25]]; 
  240.     dest[SCREENWIDTH] = colormap[source[(frac+fracstep)>>25]]; 
  241.     dest[SCREENWIDTH*2] = colormap[source[(frac+fracstep2)>>25]]; 
  242.     dest[SCREENWIDTH*3] = colormap[source[(frac+fracstep3)>>25]];
  243.     
  244.     frac += fracstep4; 
  245.  
  246.     dest[SCREENWIDTH*4] = colormap[source[frac>>25]]; 
  247.     dest[SCREENWIDTH*5] = colormap[source[(frac+fracstep)>>25]]; 
  248.     dest[SCREENWIDTH*6] = colormap[source[(frac+fracstep2)>>25]]; 
  249.     dest[SCREENWIDTH*7] = colormap[source[(frac+fracstep3)>>25]]; 
  250.  
  251.     frac += fracstep4; 
  252.     dest += SCREENWIDTH*8; 
  253.     count -= 8;
  254.     } 
  255.     
  256.     while (count > 0)
  257.     { 
  258.     *dest = colormap[source[frac>>25]]; 
  259.     dest += SCREENWIDTH; 
  260.     frac += fracstep; 
  261.     count--;
  262.     } 
  263. }
  264. #endif
  265.  
  266.  
  267. #ifndef AMIGA
  268. void R_DrawColumnLow (void) 
  269. { 
  270.     int            count; 
  271.     byte*        dest; 
  272.     byte*        dest2;
  273.     fixed_t        frac;
  274.     fixed_t        fracstep;     
  275.  
  276.     count = dc_yh - dc_yl; 
  277.  
  278.     // Zero length.
  279.     if (count < 0) 
  280.     return; 
  281.                  
  282. #ifdef RANGECHECK 
  283.     if ((unsigned)dc_x >= SCREENWIDTH
  284.     || dc_yl < 0
  285.     || dc_yh >= SCREENHEIGHT)
  286.     {
  287.     
  288.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  289.     }
  290.     //    dccount++; 
  291. #endif 
  292.     // Blocky mode, need to multiply by 2.
  293.     dc_x <<= 1;
  294.     
  295.     dest = ylookup[dc_yl] + columnofs[dc_x];
  296.     dest2 = ylookup[dc_yl] + columnofs[dc_x+1];
  297.     
  298.     fracstep = dc_iscale; 
  299.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  300.     
  301.     do 
  302.     {
  303.     // Hack. Does not work corretly.
  304.     *dest2 = *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  305.     dest += SCREENWIDTH;
  306.     dest2 += SCREENWIDTH;
  307.     frac += fracstep; 
  308.  
  309.     } while (count--);
  310. }
  311. #endif
  312.  
  313.  
  314.  
  315.  
  316. #ifndef AMIGA
  317.  
  318. //
  319. // Framebuffer postprocessing.
  320. // Creates a fuzzy image by copying pixels
  321. //  from adjacent ones to left and right.
  322. // Used with an all black colormap, this
  323. //  could create the SHADOW effect,
  324. //  i.e. spectres and invisible players.
  325. //
  326. void R_DrawFuzzColumn (void) 
  327. { 
  328.     int            count; 
  329.     byte*        dest; 
  330.     fixed_t        frac;
  331.     fixed_t        fracstep;     
  332.  
  333.     // Adjust borders. Low... 
  334.     if (!dc_yl) 
  335.     dc_yl = 1;
  336.  
  337.     // .. and high.
  338.     if (dc_yh == viewheight-1) 
  339.     dc_yh = viewheight - 2; 
  340.          
  341.     count = dc_yh - dc_yl; 
  342.  
  343.     // Zero length.
  344.     if (count < 0) 
  345.     return; 
  346.  
  347.     
  348. #ifdef RANGECHECK 
  349.     if ((unsigned)dc_x >= SCREENWIDTH
  350.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  351.     {
  352.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  353.          dc_yl, dc_yh, dc_x);
  354.     }
  355. #endif
  356.  
  357.  
  358.     // Keep till detailshift bug in blocky mode fixed,
  359.     //  or blocky mode removed.
  360.     /* WATCOM code 
  361.     if (detailshift)
  362.     {
  363.     if (dc_x & 1)
  364.     {
  365.         outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
  366.         outp (SC_INDEX+1,12); 
  367.     }
  368.     else
  369.     {
  370.         outpw (GC_INDEX,GC_READMAP); 
  371.         outp (SC_INDEX+1,3); 
  372.     }
  373.     dest = destview + dc_yl*80 + (dc_x>>1); 
  374.     }
  375.     else
  376.     {
  377.     outpw (GC_INDEX,GC_READMAP+((dc_x&3)<<8) ); 
  378.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  379.     dest = destview + dc_yl*80 + (dc_x>>2); 
  380.     }*/
  381.  
  382.     
  383.     // Does not work with blocky mode.
  384.     dest = ylookup[dc_yl] + columnofs[dc_x];
  385.  
  386.     // Looks familiar.
  387.     fracstep = dc_iscale; 
  388.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  389.  
  390.     // Looks like an attempt at dithering,
  391.     //  using the colormap #6 (of 0-31, a bit
  392.     //  brighter than average).
  393.     do 
  394.     {
  395.     // Lookup framebuffer, and retrieve
  396.     //  a pixel that is either one column
  397.     //  left or right of the current one.
  398.     // Add index from colormap to index.
  399.     *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  400.  
  401.     // Clamp table lookup index.
  402.     if (++fuzzpos == FUZZTABLE) 
  403.         fuzzpos = 0;
  404.     
  405.     dest += SCREENWIDTH;
  406.  
  407.     frac += fracstep; 
  408.     } while (count--); 
  409. } 
  410. #endif
  411.  
  412.   
  413.  
  414.  
  415. #ifndef AMIGA
  416.  
  417. //
  418. // Framebuffer postprocessing.
  419. // Creates a fuzzy image by copying pixels
  420. //  from adjacent ones to left and right.
  421. // Used with an all black colormap, this
  422. //  could create the SHADOW effect,
  423. //  i.e. spectres and invisible players.
  424. //
  425. void R_DrawFuzzColumnLow (void) 
  426. { 
  427.     int            count; 
  428.     byte*        dest; 
  429.     byte*        dest2; 
  430.     fixed_t        frac;
  431.     fixed_t        fracstep;     
  432.  
  433.     // Adjust borders. Low... 
  434.     if (!dc_yl) 
  435.     dc_yl = 1;
  436.  
  437.     // .. and high.
  438.     if (dc_yh == viewheight-1) 
  439.     dc_yh = viewheight - 2; 
  440.          
  441.     count = dc_yh - dc_yl; 
  442.  
  443.     // Zero length.
  444.     if (count < 0) 
  445.     return; 
  446.  
  447.     
  448. #ifdef RANGECHECK 
  449.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  450.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  451.     {
  452.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  453.          dc_yl, dc_yh, dc_x);
  454.     }
  455. #endif
  456.  
  457.  
  458.     // Does not work with blocky mode.
  459.     dest = ylookup[dc_yl] + columnofs[dc_x << 1];
  460.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  461.  
  462.     // Looks familiar.
  463.     fracstep = dc_iscale;
  464.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  465.  
  466.     // Looks like an attempt at dithering,
  467.     //  using the colormap #6 (of 0-31, a bit
  468.     //  brighter than average).
  469.     do 
  470.     {
  471.     // Lookup framebuffer, and retrieve
  472.     //  a pixel that is either one column
  473.     //  left or right of the current one.
  474.     // Add index from colormap to index.
  475.     *dest2 = *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]];
  476.  
  477.     // Clamp table lookup index.
  478.     if (++fuzzpos == FUZZTABLE)
  479.         fuzzpos = 0;
  480.  
  481.     dest += SCREENWIDTH;
  482.     dest2 += SCREENWIDTH;
  483.  
  484.     frac += fracstep;
  485.     } while (count--);
  486. }
  487. #endif
  488.  
  489.   
  490.  
  491.  
  492. //
  493. // R_DrawTranslatedColumn
  494. // Used to draw player sprites
  495. //  with the green colorramp mapped to others.
  496. // Could be used with different translation
  497. //  tables, e.g. the lighter colored version
  498. //  of the BaronOfHell, the HellKnight, uses
  499. //  identical sprites, kinda brightened up.
  500. //
  501. byte*    dc_translation;
  502. byte*    translationtables;
  503.  
  504. //#ifndef AMIGA
  505.  
  506. void R_DrawTranslatedColumn (void) 
  507. { 
  508.     int            count; 
  509.     byte*        dest; 
  510.     fixed_t        frac;
  511.     fixed_t        fracstep;     
  512.  
  513.     count = dc_yh - dc_yl; 
  514.     if (count < 0) 
  515.     return; 
  516.                  
  517. #ifdef RANGECHECK 
  518.     if ((unsigned)dc_x >= SCREENWIDTH
  519.     || dc_yl < 0
  520.     || dc_yh >= SCREENHEIGHT)
  521.     {
  522.     I_Error ( "R_DrawColumn: %i to %i at %i",
  523.           dc_yl, dc_yh, dc_x);
  524.     }
  525.     
  526. #endif 
  527.  
  528.  
  529.     // WATCOM VGA specific.
  530.     /* Keep for fixing.
  531.     if (detailshift)
  532.     {
  533.     if (dc_x & 1)
  534.         outp (SC_INDEX+1,12); 
  535.     else
  536.         outp (SC_INDEX+1,3);
  537.     
  538.     dest = destview + dc_yl*80 + (dc_x>>1); 
  539.     }
  540.     else
  541.     {
  542.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  543.  
  544.     dest = destview + dc_yl*80 + (dc_x>>2); 
  545.     }*/
  546.  
  547.     
  548.     // FIXME. As above.
  549.     dest = ylookup[dc_yl] + columnofs[dc_x]; 
  550.  
  551.     // Looks familiar.
  552.     fracstep = dc_iscale; 
  553.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  554.  
  555.     // Here we do an additional index re-mapping.
  556.     do 
  557.     {
  558.     // Translation tables are used
  559.     //  to map certain colorramps to other ones,
  560.     //  used with PLAY sprites.
  561.     // Thus the "green" ramp of the player 0 sprite
  562.     //  is mapped to gray, red, black/indigo. 
  563.     *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  564.     dest += SCREENWIDTH;
  565.     
  566.     frac += fracstep; 
  567.     } while (count--); 
  568. } 
  569.  
  570. //#endif
  571.  
  572.  
  573.  
  574. //
  575. // R_DrawTranslatedColumn
  576. // Used to draw player sprites
  577. //  with the green colorramp mapped to others.
  578. // Could be used with different translation
  579. //  tables, e.g. the lighter colored version
  580. //  of the BaronOfHell, the HellKnight, uses
  581. //  identical sprites, kinda brightened up.
  582. //
  583. byte*    dc_translation;
  584. byte*    translationtables;
  585.  
  586. //#ifndef AMIGA
  587.  
  588. void R_DrawTranslatedColumnLow (void) 
  589. { 
  590.     int            count; 
  591.     byte*        dest; 
  592.     byte*        dest2;
  593.     fixed_t        frac;
  594.     fixed_t        fracstep;     
  595.  
  596.     count = dc_yh - dc_yl; 
  597.     if (count < 0) 
  598.     return; 
  599.                  
  600. #ifdef RANGECHECK 
  601.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  602.     || dc_yl < 0
  603.     || dc_yh >= SCREENHEIGHT)
  604.     {
  605.     I_Error ( "R_DrawColumn: %i to %i at %i",
  606.           dc_yl, dc_yh, dc_x);
  607.     }
  608.     
  609. #endif 
  610.  
  611.  
  612.     // FIXME. As above.
  613.     dest = ylookup[dc_yl] + columnofs[dc_x << 1]; 
  614.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  615.  
  616.     // Looks familiar.
  617.     fracstep = dc_iscale; 
  618.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  619.  
  620.     // Here we do an additional index re-mapping.
  621.     do 
  622.     {
  623.     // Translation tables are used
  624.     //  to map certain colorramps to other ones,
  625.     //  used with PLAY sprites.
  626.     // Thus the "green" ramp of the player 0 sprite
  627.     //  is mapped to gray, red, black/indigo. 
  628.     *dest2 = *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  629.     dest += SCREENWIDTH;
  630.     dest2 += SCREENWIDTH;
  631.     
  632.     frac += fracstep; 
  633.     } while (count--); 
  634. } 
  635.  
  636. //#endif
  637.  
  638.  
  639.  
  640. //
  641. // R_InitTranslationTables
  642. // Creates the translation tables to map
  643. //  the green color ramp to gray, brown, red.
  644. // Assumes a given structure of the PLAYPAL.
  645. // Could be read from a lump instead.
  646. //
  647. void R_InitTranslationTables (void)
  648. {
  649.     int        i;
  650.     
  651.     translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
  652.     translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
  653.     
  654.     // translate just the 16 green colors
  655.     for (i=0 ; i<256 ; i++)
  656.     {
  657.     if (i >= 0x70 && i<= 0x7f)
  658.     {
  659.         // map green ramp to gray, brown, red
  660.         translationtables[i] = 0x60 + (i&0xf);
  661.         translationtables [i+256] = 0x40 + (i&0xf);
  662.         translationtables [i+512] = 0x20 + (i&0xf);
  663.     }
  664.     else
  665.     {
  666.         // Keep all other colors as is.
  667.         translationtables[i] = translationtables[i+256] 
  668.         = translationtables[i+512] = i;
  669.     }
  670.     }
  671. }
  672.  
  673.  
  674.  
  675.  
  676. //
  677. // R_DrawSpan 
  678. // With DOOM style restrictions on view orientation,
  679. //  the floors and ceilings consist of horizontal slices
  680. //  or spans with constant z depth.
  681. // However, rotation around the world z axis is possible,
  682. //  thus this mapping, while simpler and faster than
  683. //  perspective correct texture mapping, has to traverse
  684. //  the texture at an angle in all but a few cases.
  685. // In consequence, flats are not stored by column (like walls),
  686. //  and the inner loop has to step in texture space u and v.
  687. //
  688. int            ds_y; 
  689. int            ds_x1; 
  690. int            ds_x2;
  691.  
  692. lighttable_t*        ds_colormap; 
  693.  
  694. fixed_t            ds_xfrac; 
  695. fixed_t            ds_yfrac; 
  696. fixed_t            ds_xstep; 
  697. fixed_t            ds_ystep;
  698.  
  699. // start of a 64*64 tile image 
  700. byte*            ds_source;    
  701.  
  702. // just for profiling
  703. int            dscount;
  704.  
  705.  
  706. //
  707. // Draws the actual span.
  708. // UNUSED.
  709. #ifndef AMIGA
  710. void R_DrawSpan (void) 
  711. { 
  712.     fixed_t        xfrac;
  713.     fixed_t        yfrac; 
  714.     byte*        dest; 
  715.     int            count;
  716.     int            spot; 
  717.      
  718. #ifdef RANGECHECK 
  719.     if (ds_x2 < ds_x1
  720.     || ds_x1<0
  721.     || ds_x2>=SCREENWIDTH  
  722.     || (unsigned)ds_y>SCREENHEIGHT)
  723.     {
  724.     I_Error( "R_DrawSpan: %i to %i at %i",
  725.          ds_x1,ds_x2,ds_y);
  726.     }
  727. //    dscount++; 
  728. #endif 
  729.  
  730.     
  731.     xfrac = ds_xfrac; 
  732.     yfrac = ds_yfrac; 
  733.      
  734.     dest = ylookup[ds_y] + columnofs[ds_x1];
  735.  
  736.     // We do not check for zero spans here?
  737.     count = ds_x2 - ds_x1; 
  738.  
  739.     do 
  740.     {
  741.     // Current texture index in u,v.
  742.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  743.  
  744.     // Lookup pixel from flat texture tile,
  745.     //  re-index using light/colormap.
  746.     *dest++ = ds_colormap[ds_source[spot]];
  747.  
  748.     // Next step in u,v.
  749.     xfrac += ds_xstep; 
  750.     yfrac += ds_ystep;
  751.     
  752.     } while (count--); 
  753. } 
  754. #endif
  755.  
  756. //void R_DrawSpan_040 (void)
  757. //{
  758. //  R_DrawSpan ();
  759. //}
  760. //
  761. //void R_DrawSpan_060 (void)
  762. //{
  763. //  R_DrawSpan ();
  764. //}
  765.  
  766. // UNUSED.
  767. // Loop unrolled by 4.
  768. #if 0
  769. void R_DrawSpan (void) 
  770. { 
  771.     unsigned    position, step;
  772.  
  773.     byte*    source;
  774.     byte*    colormap;
  775.     byte*    dest;
  776.     
  777.     unsigned    count;
  778.     usingned    spot; 
  779.     unsigned    value;
  780.     unsigned    temp;
  781.     unsigned    xtemp;
  782.     unsigned    ytemp;
  783.         
  784.     position = ((ds_xfrac<<10)&0xffff0000) | ((ds_yfrac>>6)&0xffff);
  785.     step = ((ds_xstep<<10)&0xffff0000) | ((ds_ystep>>6)&0xffff);
  786.         
  787.     source = ds_source;
  788.     colormap = ds_colormap;
  789.     dest = ylookup[ds_y] + columnofs[ds_x1];     
  790.     count = ds_x2 - ds_x1 + 1; 
  791.     
  792.     while (count >= 4) 
  793.     { 
  794.     ytemp = position>>4;
  795.     ytemp = ytemp & 4032;
  796.     xtemp = position>>26;
  797.     spot = xtemp | ytemp;
  798.     position += step;
  799.     dest[0] = colormap[source[spot]]; 
  800.  
  801.     ytemp = position>>4;
  802.     ytemp = ytemp & 4032;
  803.     xtemp = position>>26;
  804.     spot = xtemp | ytemp;
  805.     position += step;
  806.     dest[1] = colormap[source[spot]];
  807.     
  808.     ytemp = position>>4;
  809.     ytemp = ytemp & 4032;
  810.     xtemp = position>>26;
  811.     spot = xtemp | ytemp;
  812.     position += step;
  813.     dest[2] = colormap[source[spot]];
  814.     
  815.     ytemp = position>>4;
  816.     ytemp = ytemp & 4032;
  817.     xtemp = position>>26;
  818.     spot = xtemp | ytemp;
  819.     position += step;
  820.     dest[3] = colormap[source[spot]]; 
  821.         
  822.     count -= 4;
  823.     dest += 4;
  824.     } 
  825.     while (count > 0) 
  826.     { 
  827.     ytemp = position>>4;
  828.     ytemp = ytemp & 4032;
  829.     xtemp = position>>26;
  830.     spot = xtemp | ytemp;
  831.     position += step;
  832.     *dest++ = colormap[source[spot]]; 
  833.     count--;
  834.     } 
  835. } 
  836. #endif
  837.  
  838.  
  839. #ifndef AMIGA
  840. //
  841. // Again..
  842. //
  843. void R_DrawSpanLow (void) 
  844. { 
  845.     fixed_t        xfrac;
  846.     fixed_t        yfrac; 
  847.     byte*        dest; 
  848.     int            count;
  849.     int            spot; 
  850.      
  851. #ifdef RANGECHECK 
  852.     if (ds_x2 < ds_x1
  853.     || ds_x1<0
  854.     || ds_x2>=SCREENWIDTH  
  855.     || (unsigned)ds_y>SCREENHEIGHT)
  856.     {
  857.     I_Error( "R_DrawSpan: %i to %i at %i",
  858.          ds_x1,ds_x2,ds_y);
  859.     }
  860. //    dscount++; 
  861. #endif 
  862.      
  863.     xfrac = ds_xfrac; 
  864.     yfrac = ds_yfrac; 
  865.  
  866.     // Blocky mode, need to multiply by 2.
  867.     ds_x1 <<= 1;
  868.     ds_x2 <<= 1;
  869.     
  870.     dest = ylookup[ds_y] + columnofs[ds_x1];
  871.   
  872.     
  873.     count = ds_x2 - ds_x1; 
  874.     do 
  875.     { 
  876.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  877.     // Lowres/blocky mode does it twice,
  878.     //  while scale is adjusted appropriately.
  879.     *dest++ = ds_colormap[ds_source[spot]]; 
  880.     *dest++ = ds_colormap[ds_source[spot]];
  881.     
  882.     xfrac += ds_xstep; 
  883.     yfrac += ds_ystep; 
  884.  
  885.     } while (count--); 
  886. }
  887. #endif
  888.  
  889. //
  890. // R_InitBuffer 
  891. // Creats lookup tables that avoid
  892. //  multiplies and other hazzles
  893. //  for getting the framebuffer address
  894. //  of a pixel to draw.
  895. //
  896. void
  897. R_InitBuffer
  898. ( int        width,
  899.   int        height ) 
  900. { 
  901.     int        i, offset;
  902.  
  903.     // Handle resize,
  904.     //  e.g. smaller view windows
  905.     //  with border and/or status bar.
  906.     viewwindowx = (SCREENWIDTH-width) >> 1; 
  907.  
  908.     // Column offset. For windows.
  909.     for (i=0 ; i<width ; i++) 
  910.     columnofs[i] = viewwindowx + i;
  911.  
  912.     // Samw with base row offset.
  913.     if (width == SCREENWIDTH) 
  914.     viewwindowy = 0; 
  915.     else 
  916.     viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 
  917.  
  918.     // Preclaculate all row offsets.
  919.     offset = viewwindowy * SCREENWIDTH;
  920.     for (i=0 ; i<height ; i++) {
  921.     ylookup[i] = screens[0] + offset;
  922.         ylookup2[i] = ylookup[i] + viewwindowx;
  923.         offset += SCREENWIDTH;
  924.     }
  925. } 
  926.  
  927.  
  928.  
  929.  
  930. //
  931. // R_FillBackScreen
  932. // Fills the back screen with a pattern
  933. //  for variable screen sizes
  934. // Also draws a beveled edge.
  935. //
  936. void R_FillBackScreen (void) 
  937. { 
  938.     byte*    src;
  939.     byte*    dest; 
  940.     int        x;
  941.     int        y; 
  942.     patch_t*    patch;
  943.  
  944.     // DOOM border patch.
  945.     char    name1[] = "FLOOR7_2";
  946.  
  947.     // DOOM II border patch.
  948.     char    name2[] = "GRNROCK";    
  949.  
  950.     char*    name;
  951.     
  952.     if ((scaledviewwidth == SCREENWIDTH)&&(viewheight==SCREENHEIGHT))
  953.     return;
  954.     
  955.     if ( gamemode == commercial)
  956.     name = name2;
  957.     else
  958.     name = name1;
  959.     
  960.     src = W_CacheLumpName (name, PU_CACHE); 
  961.     dest = screens[1]; 
  962.      
  963.     for (y=0 ; y<SCREENHEIGHT/*-SBARHEIGHT*/ ; y++)
  964.     { 
  965.     for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  966.     { 
  967.         memcpy (dest, src+((y&63)<<6), 64); 
  968.         dest += 64; 
  969.     } 
  970.  
  971.     if (SCREENWIDTH&63) 
  972.     { 
  973.         memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  974.         dest += (SCREENWIDTH&63); 
  975.     } 
  976.     } 
  977.     if (SCREENWIDTH==scaledviewwidth)
  978.      return;
  979.  
  980.    if ((viewwindowy-8)>=0)
  981.      {
  982.      patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  983.      for (x=0 ; x<scaledviewwidth ; x+=8)
  984.        V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  985.      }
  986.    if ((viewwindowy+viewheight+8)<(SCREENHEIGHT-SBARHEIGHT))
  987.      {
  988.      patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  989.      for (x=0 ; x<scaledviewwidth ; x+=8)
  990.        V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  991.      }
  992.    if ((viewwindowx-8)>=0)
  993.      {
  994.      patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  995.      for (y=0 ; y<viewheight ; y+=8)
  996.        V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  997.      }
  998.    if ((viewwindowx+scaledviewwidth+8)<SCREENWIDTH)
  999.      {
  1000.      patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  1001.      for (y=0 ; y<viewheight ; y+=8)
  1002.        V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  1003.      }
  1004.  
  1005.     // Draw beveled edge.
  1006.     if (((viewwindowx-8)>=0)&&((viewwindowy-8)>=0))
  1007.       V_DrawPatch (viewwindowx-8,
  1008.          viewwindowy-8,
  1009.          1,
  1010.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  1011.     
  1012.     if (((viewwindowx+scaledviewwidth+8)<SCREENWIDTH)&&((viewwindowy-8)>=0))
  1013.       V_DrawPatch (viewwindowx+scaledviewwidth,
  1014.          viewwindowy-8,
  1015.          1,
  1016.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  1017.  
  1018.     if (((viewwindowx-8)>=0)&&((viewwindowy+viewheight+8)<(SCREENHEIGHT-SBARHEIGHT)))
  1019.       V_DrawPatch (viewwindowx-8,
  1020.          viewwindowy+viewheight,
  1021.          1,
  1022.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  1023.     
  1024.     if (((viewwindowx+scaledviewwidth+8)<SCREENWIDTH)&&((viewwindowy+viewheight+8)<(SCREENHEIGHT-SBARHEIGHT)))
  1025.       V_DrawPatch (viewwindowx+scaledviewwidth,
  1026.          viewwindowy+viewheight,
  1027.          1,
  1028.          W_CacheLumpName ("brdr_br",PU_CACHE));
  1029.  
  1030.  
  1031. #if 0
  1032.  
  1033.     if (scaledviewwidth == 320)
  1034.     return;
  1035.     
  1036.     if ( gamemode == commercial)
  1037.     name = name2;
  1038.     else
  1039.     name = name1;
  1040.     
  1041.     src = W_CacheLumpName (name, PU_CACHE); 
  1042.     dest = screens[1]; 
  1043.      
  1044.     for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  1045.     { 
  1046.     for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  1047.     { 
  1048.         memcpy (dest, src+((y&63)<<6), 64); 
  1049.         dest += 64; 
  1050.     } 
  1051.  
  1052.     if (SCREENWIDTH&63) 
  1053.     { 
  1054.         memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  1055.         dest += (SCREENWIDTH&63); 
  1056.     } 
  1057.     } 
  1058.     
  1059.     patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  1060.  
  1061.     for (x=0 ; x<scaledviewwidth ; x+=8)
  1062.     V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  1063.     patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  1064.  
  1065.     for (x=0 ; x<scaledviewwidth ; x+=8)
  1066.     V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  1067.     patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  1068.  
  1069.     for (y=0 ; y<viewheight ; y+=8)
  1070.     V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  1071.     patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  1072.  
  1073.     for (y=0 ; y<viewheight ; y+=8)
  1074.     V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  1075.  
  1076.  
  1077.     // Draw beveled edge. 
  1078.     V_DrawPatch (viewwindowx-8,
  1079.          viewwindowy-8,
  1080.          1,
  1081.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  1082.     
  1083.     V_DrawPatch (viewwindowx+scaledviewwidth,
  1084.          viewwindowy-8,
  1085.          1,
  1086.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  1087.     
  1088.     V_DrawPatch (viewwindowx-8,
  1089.          viewwindowy+viewheight,
  1090.          1,
  1091.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  1092.     
  1093.     V_DrawPatch (viewwindowx+scaledviewwidth,
  1094.          viewwindowy+viewheight,
  1095.          1,
  1096.          W_CacheLumpName ("brdr_br",PU_CACHE));
  1097.  
  1098. #endif
  1099.  
  1100. } 
  1101.  
  1102.  
  1103. //
  1104. // Copy a screen buffer.
  1105. //
  1106. void
  1107. R_VideoErase
  1108. ( unsigned    ofs,
  1109.   int        count ) 
  1110. { 
  1111.   // LFB copy.
  1112.   // This might not be a good idea if memcpy
  1113.   //  is not optiomal, e.g. byte by byte on
  1114.   //  a 32bit CPU, as GNU GCC/Linux libc did
  1115.   //  at one point.
  1116.     memcpy (screens[0]+ofs, screens[1]+ofs, count); 
  1117. } 
  1118.  
  1119.  
  1120. //
  1121. // R_DrawViewBorder
  1122. // Draws the border around the view
  1123. //  for different size windows?
  1124. //
  1125. //void
  1126. //V_MarkRect
  1127. //( int        x,
  1128. //  int        y,
  1129. //  int        width,
  1130. //  int        height ); 
  1131.  
  1132. void R_DrawViewBorder (void) 
  1133. { 
  1134.     int        top;
  1135.     int        side,side2;
  1136.     int        ofs;
  1137.     int        i; 
  1138.  
  1139.     //if screenwidth>320, draw stuff around status bar, even if scaledviewwidth==SCREENWIDTH
  1140.     if ((SCREENWIDTH>320)&&(SCREENHEIGHT!=viewheight))
  1141.       {
  1142.       ofs=(SCREENHEIGHT-SBARHEIGHT)*SCREENWIDTH;
  1143.       side=(SCREENWIDTH-320)/2; side2=side*2;
  1144.       R_VideoErase(ofs,side);
  1145.  
  1146.       ofs+=(SCREENWIDTH-side);
  1147.       for (i=1;i<SBARHEIGHT;i++)
  1148.         {
  1149.         R_VideoErase(ofs,side2);
  1150.         ofs+=SCREENWIDTH;
  1151.         }
  1152.       R_VideoErase(ofs,side);
  1153.       }
  1154.  
  1155. //    if (scaledviewwidth == SCREENWIDTH) 
  1156.     if (viewheight>=(SCREENHEIGHT-SBARHEIGHT))
  1157.     return; 
  1158.   
  1159.     top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  1160.     side = (SCREENWIDTH-scaledviewwidth)/2; 
  1161.  
  1162.     // copy top and one line of left side 
  1163.     R_VideoErase (0, top*SCREENWIDTH+side); 
  1164.  
  1165.     // copy one line of right side and bottom 
  1166.     ofs = (viewheight+top)*SCREENWIDTH-side; 
  1167.     R_VideoErase (ofs, top*SCREENWIDTH+side); 
  1168.  
  1169.     // copy sides using wraparound 
  1170.     ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  1171.     side <<= 1;
  1172.     
  1173.     for (i=1 ; i<viewheight ; i++) 
  1174.     { 
  1175.     R_VideoErase (ofs, side); 
  1176.     ofs += SCREENWIDTH; 
  1177.     } 
  1178.  
  1179.     // ? 
  1180.     I_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
  1181. } 
  1182.  
  1183.  
  1184.